home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Fixation 1.3 / graphutil.c < prev    next >
Text File  |  1996-01-18  |  3KB  |  139 lines
  1. // airborneutil.c
  2.  
  3. #include <QDOffscreen.h>
  4. #include <stdlib.h>
  5. #include <math.h>
  6. #include "error.h"
  7.  
  8. #include "graphutil.h"
  9.  
  10.  
  11.     // allocates memory for a gworld and sets clip stuff
  12. void makegworld(GWorldPtr *gw, Rect *bounds, int depth, CTabHandle dacolors)
  13. {
  14.     GDHandle            SaveGD;
  15.     CGrafPtr            SavePort;
  16.     OSErr result;
  17.     int a;
  18.     
  19.     GetGWorld(&SavePort, &SaveGD);
  20.     
  21.         // note that all gworlds are kept local, which destroys
  22.         // graphics acceleration hardware
  23.     result = NewGWorld(gw, depth, bounds, dacolors, nil, keepLocal);
  24.     if (result) {
  25.     //    stdmessage("\pSorry, not enough memory to start up.");
  26.         verify(false);
  27.     }
  28.     verify(gw);
  29.     a = LockPixels((*gw)->portPixMap);
  30.     verify(a);
  31.     
  32.     SetGWorld(*gw, nil);
  33.     ClipRect(&(**gw).portRect);
  34.     PaintRect(&(**gw).portRect);
  35.     
  36.     SetGWorld(SavePort, SaveGD);
  37. }
  38.  
  39.     // reads a texture as a PICT resource and copies it into given GWorld
  40. void loadtexture(GWorldPtr gw, int id)
  41. {
  42.     GDHandle            SaveGD;
  43.     CGrafPtr            SavePort;
  44.     Rect r;
  45.     PicHandle ph;
  46.     
  47.     verify(gw);
  48.     ph = GetPicture(id);
  49.     verify(!ResError());
  50.     verify(ph);
  51.     r = (**ph).picFrame;        // get rect of pict
  52.     verify(r.right > r.left);
  53.     GetGWorld(&SavePort, &SaveGD);
  54.     
  55.     SetGWorld(gw, nil);
  56.     DrawPicture(ph, &r);
  57.     ReleaseResource((Handle) ph);
  58.     
  59.     SetGWorld(SavePort, SaveGD);
  60. }
  61.  
  62.     // read in the pictures and store them in offscreen pixmaps
  63.     // starts at 128, masks at base + id
  64.     // goes until maxresid (if -1, go until hit blank)
  65. void GetPixFromResources(short base, int numpix, Rect blockrect[],
  66.         GWorldPtr bpix[], GWorldPtr bmask[], CTabHandle dacolors)
  67. {
  68.     Rect stdrect = {0, 0, 32, 32};
  69.     GDHandle            SaveGD;
  70.     CGrafPtr            SavePort;
  71.     int curid;
  72.     PicHandle p;
  73.  
  74.     GetGWorld(&SavePort, &SaveGD);
  75.     
  76.     curid = 0;    // start here
  77.         // get other stuff
  78.     while (1) {
  79.         p = GetPicture(curid + base);
  80.         if (!p && numpix < 0)
  81.             break;        // we done
  82.         if (!p)
  83.             blockrect[curid] = stdrect;
  84.         else
  85.             blockrect[curid] = (**p).picFrame;
  86.         OffsetRect(&blockrect[curid], -blockrect[curid].left, -blockrect[curid].top);
  87.         makegworld(&(bpix[curid]), &blockrect[curid], 8, dacolors);
  88.         if (p) {
  89.                 // paint the picture into a pixmap, thus storing it that way
  90.             SetGWorld(bpix[curid], nil);
  91.             DrawPicture(p, &blockrect[curid]);
  92.             ReleaseResource((Handle) p);
  93.         }
  94.  
  95.             // now get the mask, if it exists
  96.         if (bmask) {
  97.             p = GetPicture(curid + base + 1000);
  98.             if (!p)        // no mask for this one
  99.                 bmask[curid] = 0;
  100.             else {
  101.                 makegworld(&(bmask[curid]), &blockrect[curid], 1, 0);
  102.                 SetGWorld(bmask[curid], nil);
  103.                 EraseRect(&blockrect[curid]);
  104.                 DrawPicture(p, &blockrect[curid]);
  105.                 ReleaseResource((Handle) p);
  106.             }
  107.         }
  108.         
  109.         curid++;
  110.         if (numpix > 0 && curid >= numpix)        // we done
  111.             break;
  112.     }
  113.  
  114. /*    if (pgGameWindDepth != 8) {
  115.             // we now convert all pixmaps into the depth of the gamewindow
  116.         for (i=0;i<maxPix;i++) {
  117.             if (!bpix[i])
  118.                 continue;
  119.             result = NewGWorld(&tempgw, 0, &blockrect[i], 0, nil, 0);
  120.             if (result)
  121.                 seriousError(ePartitionTooSmall);
  122.             SetGWorld(tempgw, nil);
  123.             a = LockPixels(tempgw->portPixMap); verify(a);
  124.             ClipRect(&(*tempgw).portRect);
  125.             CopyBits ((BitMap *) *(bpix[i]->portPixMap), (BitMap *) *(tempgw->portPixMap), 
  126.                 &blockrect[i], &blockrect[i], srcCopy, nil);
  127.             UnlockPixels(bpix[i]->portPixMap);
  128.             DisposeGWorld(bpix[i]);
  129.             bpix[i] = tempgw;
  130.             tempgw = 0;
  131.         }
  132.     }
  133.  
  134.  
  135. */
  136.  
  137.     SetGWorld(SavePort, SaveGD);    // restore original world (save the Earth)
  138. }
  139.